home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / music / cthugha5.zip / CTHU5SRC.ZIP / AUDIOSBP.C < prev    next >
C/C++ Source or Header  |  1994-08-19  |  5KB  |  277 lines
  1. //
  2. // Cthugha - Audio Seeded Image Processing
  3. //
  4. // Zaph, Digital Aasvogel Group, Torps Productions 1993-1994
  5. //
  6. // Soundblaster Stereo version by Daniel Sachs, 1994
  7. //
  8.  
  9.  
  10. #include <stdio.h>
  11. #include <dos.h>
  12. #include <io.h>
  13. #include <fcntl.h>
  14. #include <stdlib.h>
  15. #include <math.h>
  16. #include <conio.h>
  17. #include <assert.h>
  18.  
  19. #include "sb_drive.h"
  20. #include "dma.h"
  21.  
  22. #include "cthugha.h"
  23. //#include "sb.h"
  24.  
  25. extern int (*init_audio)(void);
  26. extern void (*close_audio)(void);
  27. extern int (*audio_firsttime)(void);
  28. extern int (*audio_everytime)(int wait);
  29.  
  30. extern int  (*get_level)(int channel);
  31. extern void (*set_level)(int channel, int level);
  32. extern int  (*level_incr)(int channel);
  33.  
  34. extern void (*set_input)(enum device_list device);
  35.  
  36. extern enum device_list { CDInput, LineInput, MicInput } device;
  37. extern void draw_text(int xpos, int ypos, int size, int colour, char *tbuf);
  38.  
  39. int load_drv(void);
  40.  
  41. int SBok=0;
  42.  
  43. extern int sample_stereo;
  44.  
  45. struct dsp_device_caps *caps;
  46.  
  47. int port, dma, irq,dma16;
  48.  
  49. extern int SBport;
  50.  
  51. extern int display_flag;
  52. extern int wait_flag;
  53. extern unsigned actual_rate;
  54.  
  55. static unsigned last_rate = 65535;
  56. static int last_stereo = -1;
  57.  
  58. void SB_close(void)
  59. {
  60.     if (SBok) {
  61.         dsp_reset();
  62.         dsp_close();
  63.     }
  64. }
  65.  
  66.  
  67. int SB_firsttime(void)
  68. {
  69.     static int prev=128;
  70.     int noisy=0,last=0;
  71.     static int firsttime=1;
  72.  
  73.     dma_reset(SBdma);
  74.     dsp_reset();
  75.  
  76.     if( sample_stereo && !(caps->max_8bit_rec_s) )
  77.         sample_stereo = 0;
  78.  
  79.     set_input(device);
  80.  
  81.     if( sample_stereo )
  82.         sample_rate = min(sample_rate,caps->max_8bit_rec_s);
  83.     else
  84.         sample_rate = min(sample_rate,caps->max_8bit_rec);
  85.  
  86.     sample_rate = max(sample_rate,caps->min_speed);
  87.  
  88.     if( !(actual_rate = dsp_set_record(sample_rate,sample_stereo,8,0)) )
  89.         assert( (actual_rate = dsp_set_record(11111,0,8,0)) );
  90.  
  91.     last_rate   = sample_rate;
  92.     last_stereo = sample_stereo;
  93.  
  94.     return 0;
  95. }
  96.  
  97.  
  98. int SB_everytime(int wait)
  99. {
  100.     int x,y;
  101.     static int prev=128;
  102.     unsigned char far *sbuff ;
  103.     int noisy=0,last=0;
  104.     static int firsttime=1;
  105.  
  106.     static int page;
  107.  
  108.     if( (sample_rate != last_rate) || (sample_stereo != last_stereo) )
  109.             SB_firsttime();
  110.  
  111. //    if( page == 0 )
  112.     {
  113.         while (dsp_read(voice_buffer) > 1)
  114.             if( wait )
  115.             {
  116.                 if( kbhit() )
  117.                 break;
  118.             }
  119.             else
  120.             {
  121.                 wait_flag = 0;
  122.                 return 0;
  123.             }
  124.     }
  125.  
  126. /*    page = 1;
  127.  
  128.     if( sample_stereo )
  129.         while( dsp_read(voice_buffer + buffer_size) > 1 )
  130.             if( wait )
  131.             {
  132.                 if( kbhit() )
  133.                     break;
  134.             }
  135.             else
  136.             {
  137.                 wait_flag = 0;
  138.                 return 0;
  139.             }
  140.  
  141.  
  142.     page = 0;
  143. */
  144.     sbuff=voice_buffer ;
  145.     sbuff += 6;
  146.  
  147.     last=*sbuff;
  148. //    sbuff++;
  149.     for (x=0; x<70; x+=2) {
  150.         //align...
  151.         if ((*sbuff)>=prev && last<prev-1) {
  152.             break;
  153.         } else {
  154.             last= *sbuff;
  155.             sbuff++;
  156.  
  157.             if( sample_stereo )
  158.                 sbuff++;
  159.         }
  160.     }
  161.  
  162.     prev=*sbuff;
  163.  
  164.     if( sample_stereo )
  165.         for (x=0; x<BUFF_WIDTH; x++) {
  166.             stereo[x][0]=*sbuff++;
  167.             stereo[x][1]=*sbuff++;
  168.         }
  169.     else
  170.         for (y=0; y<2; y++)
  171.             for (x=0; x<BUFF_WIDTH; x++) {
  172.                 stereo[x][y]=*sbuff++;
  173.             }
  174.  
  175.     return 1;
  176. }
  177.  
  178.  
  179. void SB_set_input(enum device_list device)
  180. {
  181.     static int mono[] =  { CD_IN  , LINE_IN  , MIC_IN };
  182.     static int left[] =  { CD_IN_L, LINE_IN_L, MIC_IN };
  183.     static int right[] = { CD_IN_R, LINE_IN_R, MIC_IN };
  184.  
  185.     if( SBtype == 3 )
  186.     {
  187.         mix_set_input(mono[device]);
  188.     }
  189.     else if( SBtype >= 4 )
  190.     {
  191.         if( sample_stereo )
  192.         {
  193.             mix_set_sb16_input(MIXleft ,left [device]);
  194.             mix_set_sb16_input(MIXright,right[device]);
  195.         }
  196.         else
  197.             mix_set_sb16_input(MIXboth,mono[device]);
  198.     }
  199. }
  200.  
  201. void SB_set_level(int channel, int level)
  202. {
  203.     mix_write(channel,MIXboth,level);
  204. }
  205.  
  206. int SB_get_level(int channel)
  207. {
  208.     return mix_read(channel,MIXboth);
  209. }
  210.  
  211. int SB_level_incr(int channel)
  212. {
  213.     if( SBtype >= 4 )
  214.     switch( channel )
  215.     {
  216.         case MIXtreble:
  217.         case MIXbass:
  218.                 return 16;
  219.  
  220.         case MIXgain:
  221.         case MIXin_gain:
  222.         case MIXspeaker:
  223.                 return 64;
  224.  
  225.         default:
  226.                 return 8;
  227.     }
  228.     else
  229.         return( channel == MIXmicrophone ? 64 : 32 );
  230. }
  231.  
  232. int SB_init()
  233. {
  234.     sb_get_params(&port,&dma,&irq,&dma16);
  235.  
  236.     buffer_size=2*BUFF_WIDTH+100;
  237.     printf("IO 0x%x  IRQ %d  DMA %d  DMA16 %d\n",port, irq, dma, dma16);
  238.     SBok = dsp_open(port,dma,irq,dma16,buffer_size,2);
  239.     SBport=port;
  240.  
  241.     if( SBok )
  242.         printf("Soundblaster %sfound, version %i.\n",(SBtype < 3) ? "" : (SBtype >= 4) ? "16 " : "Pro ", dsp_version() );
  243.     else
  244.     {
  245.         printf("Soundblaster not found!\n");
  246.         return 1;
  247.     }
  248.  
  249.     caps = dsp_get_device_caps();
  250.  
  251.     sample_rate = caps->max_8bit_rec_s;
  252.     sample_stereo = 1;
  253.  
  254.     if( sample_rate == 0 ) {
  255.         sample_rate = caps->max_8bit_rec;
  256.         sample_stereo = 0;
  257.     }
  258.  
  259.     voice_buffer = malloc(buffer_size*2);
  260.  
  261.     assert( voice_buffer != NULL );
  262.  
  263.     close_audio = SB_close;
  264.     audio_firsttime = SB_firsttime;
  265.     audio_everytime = SB_everytime;
  266.  
  267.     set_input = SB_set_input;
  268.  
  269.     get_level = SB_get_level;
  270.     set_level = SB_set_level;
  271.  
  272.     level_incr = SB_level_incr;
  273.  
  274.     return !SBok;
  275.  
  276. }
  277.